// 接口抽象的 没有具体的实现 只是用来定义的

interface IMySum {
  (x: number, y: number): number;
}
let sum: IMySum = (x: number, y: number): number => x + y;

// interface和type有什么区别。 type可以使用联合类型 、交叉类型 都首选我们的 type
// 接口可以被继承和实现

// 描述对象  接口称之为对形状的描述
interface IVal {
  a: number;
  b: number;
}
function getVal(obj: IVal) {}
getVal({ a: 1, b: 2 });

// 混合接口  有一个值他是一个函数 函数上还有属性 给函数增加自定义属性

interface IConter {
  (): number; // 他必须是一个函数
  count: number; // 函数要有个属性count
}
const counter: IConter = (): number => {
  return ++counter.count;
};
counter.count = 100;

let r1 = counter();
let r2 = counter();
console.log(r1, r2);

// 描述对象
// 接口中增加? 表示可以可无
// 有一些属性是必填的有些的是随机的  可以采用任意类型 来添加属性
interface IFruit {
  readonly taste: string; // readonly表示仅读属性
  color: string;
  size?: number;
  // [xxx:string]:any
}
let bannaer: IFruit = {
  // 必须包含taste 和 color
  taste: "甜的",
  color: "黄色",
  size: 15,
  // a:1
};
let tomato: IFruit = {
  // 必须包含taste 和 color
  taste: "甜的",
  color: "黄色",
  a: 1,
} as IFruit; // 断言也要考虑安全性 必须得存在在定义的属性中，而且断言后多余的属性不能使用

// 类型兼容性 我们可以把兼容的类型赋予给这个类型
let w = {
  // 必须包含taste 和 color
  taste: "甜的",
  color: "黄色",
  a: 1,
};
let apple: IFruit = w; // 我希望我取的媳妇有车有房  但是真实娶的有车有房又有钱 = 满足了我的需求
// 采用readonly 给接口添加描述

// 接口可以被实现
interface ISpeakChinese {
  // 接口要求都必须是抽象的
  speakChinese: () => void; // 描述有一个属性speakChinese 是一个函数
}
interface ISpeakEnglish {
  speakEnglish: () => void;
}
// 这是实现 要求实现的类必须得有实现
// class Speak implements ISpeakChinese,ISpeakEnglish {
//     // 用接口来约束属性的返回值时 void表示不校验 不关心返回值
//     speakChinese(){
//         return ;
//     }
//     speakEnglish(){
//         return 'abc'
//     }
// }
// 抽象类 就是专门为别人提供继承的接口
abstract class Animal {
  // 不能被new 抽象类可以有非抽象方法
  abstract eat(): void; // 让继承的子类来实现
  abstract name: string;

  drink() {
    console.log("dirnk");
  }
}
class Cat extends Animal {
  name: string = "";
  eat() {}
}
// 接口中的属性和方法都是抽象的

interface IA {
  a: 1; // 这表示的是 1当做了类型 这个类型叫字面量类型
}

// 接口还具备继承的能力

interface IFruit1 {
  readonly taste: string;
}
interface IFruit2 extends IFruit1 {
  readonly color: string;
}
let f:IFruit2 = {
    taste:'',
    color:''
}
class A{
  a:string = ''
  eat(){ console.log('1')}
}
interface Xx extends A{
    b:string,
    drink:()=>void
}
// 接口可以描述形状 （？ 可选属性 readonly 仅读属性  任意属性[xx:string]:any）  接口可以被继承，可以被实现。 接口中的内容都是抽象的

// 抽象类 可以有实现的方法 ， 但是只能被继承

export {};
